6-1. Error Messages of Omikron Basic | Contents | 6-3. MacOS Error Messages

Chapter 6-2 Omikron Basic Compiler Error Messages

Error messages of the compiler are output to the compiler window during compilation and lead to the termination of the compiling process. Clicking on the error message causes a direct jump to the corresponding location in the program.

Incorrect Use of DEFAULT
DEFAULT or OTHERWISE must always be the last branches of a SELECT ... CASE structure.

MEMORY_BLOCK Too Long
An attempt was made to define a MEMORY_BLOCK that is larger than 32 MB.

Structure Too Long
In the case of IF ... THEN ... ELSE ... ENDIF, FOR ... NEXT, REPEAT ... UNTIL, and WHILE ... WEND structures, Omikron Basic 6 allows structure lengths of up to 32 MB, so that this error message rarely occurs in this connection. However, SELECT ... CASE ... END_SELECT structures may contain a maximum of 32 KB and therefore can cause this error message. A recommended remedy is to take parts of the program out of the structure and (for example, by placing them into a procedure and then calling them from within this structure).

SWAP Type Incorrect
Different types of variables follow a SWAP command.

Type Mismatch
An attempt was made during a procedure to pass a number to a string or vise versa.

Uncompiled Modify Operation
+= and *= are not allowed together with strings.

Undefined Statements or DIMs
GOTO, GOSUB, etc. point to lines or labels that do not exist. A variable field must be dimensioned before it is used. After every CLEAR, all fields must be re-dimensioned again. 

Illegal Constant Assignment

An attempt was made to assign a value to a constant at least twice or the expression, which is to be assigned to the constant, is not constant.

Illegal Constant Type
Fields and strings are not permitted as constants. Only individual variables can be used as constants.

Illegal EXIT
EXIT may be used only without parameters, as EXIT 1 or EXIT -1. EXIT TO is only allowed for exiting a loop, however not for exiting procedures and functions.

Different Matrix Types
An attempt was made to apply a matrix operation to two matrices of different data types.

Too Many Constants
Since the processor of the PowerPC does not allow for any immediate operands with more than 16 bits, all constants must be stored in a table. Omikron Basic allocates 64 KB for this case. If more constants are used than fit into the table, this error message will appear.

Too Many Parameters
Too many parameters were passed to the command MAC_OS. Max. 252 bytes are available for the passing of parameters.

Too Many Variables
Omikron Basic's variable area encompasses 64K. The values of individual variables are directly located in this memory area while in the case of strings and fields only a pointer to the corresponding object in the variable segment is set up. Even very long programs using more than 1 MB generally require hardly more than 16K for their variables. If problems should still occur at onetime or another, it is possible to save space by using field elements instead of individual variables (e.g., use A(0),A(1),A(2),A(3),A(4),A(5) instead of A0,A1,A2,A3,A4,A5). In this case scenario, only 4 bytes are then required for the array pointer instead of the 24 bytes for the 6 individual variables.

Not Enough Reserved Memory
The compiler does not have enough free memory available in order to compile the program to its end. More memory can be assigned to Omikron Basic in the menu 'Mode/Memory Settings'. Further information can be found in the chapter 'The Editor'.

Note:
There are a variety of other error messages that can occur. These are either self-explanatory (e.g., IF without THEN) or are intended for programmers of Omikron Basic to locate errors in the compiler. If an error message is unintelligible, please, send the program where the error occurred to Berkhan-Software, Entwicklung und Vertrieb, Alt-Isenhagen 19, D-29386 Hankensbüttel, Germany.

Warning Messages of the Compiler
are output in the compiler window during the compilation process and represent warnings or notes explaining issues that can lead to problems during program execution later on. However, compilation is not terminated in case of these types of messages.

Note: Warning messages of the compiler can be deactivated using COMPILER "WARNINGS OFF."

Command Is Not Implemented
A command was used, which is not implemented in Omikron Basic 6. This command has to be replaced by another command.

Division by Constant Zero
A division by a constant with the value 0 was attempted.

RETURN Type Mismatch
A multi-line function must return the variable type, which it carries as a postfix in the name.

Incorrect: DEF FN Add#(X,Y):RETURN X+Y (an integer is returned although the function carries the float postfix).
Correct: DEF FN Add#(X#,Y#):RETURN X#+Y#
Also correct: DEF FN Add#(X,Y):RETURN CDBL(X+Y)

FPU Overflow This warning occurs if during the compilation process a conversion to the floating point format is taking place, which cannot display the desired number because it is either too large or too small.

INLINE Length Must Be a Multiple of 8
The length of the string expression behind INLINE must be a multiple of 8 because every command of the PowerPC is exactly 4 bytes long and 8 hexadecimal numbers are required to encode 4 bytes.

MEMORY_BLOCK Size Error
A MEMORY_BLOCK does not have the size it should have according to the specifications in the command. Something such as this can happen if the same block was defined several times (the identifier behind the command may be used only once).

Tokenizer Error Line -: XXXXX
The compiler encountered a line that the tokenizer of the editor had already marked as incorrect.

Unused Statements
The procedures, functions, and label listed after the warning was issued are not used anywhere in the entire program. Therefore, they can be deleted or commented out.

Bad COMPILER Statement
A compiler control word was used, which does not exist. Therefore, the error can only occur in lines containing COMPILER statements.

Illegal ON ...
The command ON was used in an illegal syntax.

Overflow Data

An attempt was made to assign a value to an integer constant that lies outside of the value range for this type.

XYZ Defined Twice
The procedure or function XYZ has been defined twice. The compiling is continued since it is possible to produce a runable program in spite of the double definition. The compiler works as follows in this instance:
All calls located in the lines prior to the first definition point towards the first definition. The same applies to all calls located between the first and second definition. Only those calls located behind the second definition will also point towards the second definition.
Double definitions are usually not created on purpose and should be avoided by renaming the one procedure or function. However, double definitions might also serve a purpose. For example, if a program is to be written in such a way as to make it compileable by different operating systems. In this case, one just has to define those procedures twice that have to be different for the two systems and then control those procedures that are to be translated by the compiler via switches. See also COMPILER ON|OFF, COMPILER"DEF_CONST", and COMPILER "CIE".